package digui;

import javax.swing.tree.TreeNode;

public class diguiwenti {
//    https://leetcode.cn/problems/reverse-linked-list/
//    public ListNode reverseList(ListNode head) {
//        if(head==null||head.next==null){
//            return head;
//        }
//        ListNode newHead=reverseList(head.next);
//        head.next.next=head;
//        head.next=null;
//        return newHead;
//
//    }

//    https://leetcode.cn/problems/merge-two-sorted-lists/?envType=problem-list-v2&envId=DnfV22hg
//    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
//        if(list1==null){
//            return list2;
//        }
//        if(list2==null){
//            return list1;
//        }
//        if(list1==null&&list2==null){
//            return list1;
//        }
//        if(list1.val<=list2.val){
//            list1.next=mergeTwoLists(list1.next,list2);
//            return list1;
//        }else{
//            list2.next=mergeTwoLists(list1,list2.next);
//            return list2;
//        }
//
//    }


//    https://leetcode.cn/problems/swap-nodes-in-pairs/  交换链表的两个节点
//        public ListNode swapPairs(ListNode head) {
//            if(head==null||head.next==null){
//                return head;
//            }
//            ListNode tmp=swapPairs(head.next.next);
//            ListNode cur=head.next;
//            head.next=tmp;
//            cur.next=head;
//            return cur;
//        }

//    https://leetcode.cn/problems/powx-n/  快速幂
    public static double myPow(double x, int n) {
        //使用long 防止溢出
        long N=n;
        return N<0?1.0/Pow(x,-N):Pow(x,N);
    }
    public static double Pow(double x, long n) {
        if(n==0){
            return 1.0;
        }
        double tmp=Pow(x, n/2);
        return n%2==0?tmp*tmp:tmp*tmp*x;
    }



    //https://leetcode.cn/problems/evaluate-boolean-binary-tree/ 二叉树的dfs和递归
//    class Solution {
//        public boolean evaluateTree(TreeNode root) {
//            if(root.left==null&&root.right==null){
//                if(root.val==0){
//                    return false;
//                }
//                if(root.val==1){
//                    return true;
//                }
//            }
//            // evaluateTree(root.left);
//            // evaluateTree(root.right);
//            if(root.val==2){
//                return evaluateTree(root.left)||evaluateTree(root.right);
//            }
//            if(root.val==3){
//                return evaluateTree(root.left)&&evaluateTree(root.right);
//            }
//            return false;
//        }
//    }

//    https://leetcode.cn/problems/sum-root-to-leaf-numbers/
    public static class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
         this.val = val;
          this.left = left;
          this.right = right;
      }
  }
    public static int sumNumbers(TreeNode root) {
        int presum=root.val;
        return dfs(root,0);
    }
    public static int dfs(TreeNode root,int presum){
        if(root==null){
            return 0;
        }
        String string_presum=String.valueOf(presum);
        //会输出1root.val
        int m=root.val;
//        string_presum=string_presum+"root.val";
//        string_presum=string_presum+"m";
        string_presum=string_presum+String.valueOf(root.val);
        int num=Integer.parseInt(string_presum);
        if(root.left==null&&root.right==null){
            return num;
        }
        return dfs(root.left,num)+dfs(root.right,num);
    }

    public static void main(String[] args) {
        TreeNode treeNode=new TreeNode(1);
        treeNode.left=new TreeNode(2);
        treeNode.right=new TreeNode(3);
        int i = sumNumbers(treeNode);
        System.out.println(i);
    }
}
